SherbyNet - /page/wikibook/entry.mu

Micron Document

<!DOCTYPE html>

<title>Array programming</title>

</head>

Array programming

</h1>

</header>

In <a href="Computer_science" title="Computer science">computer science</a>, array programming refers to solutions that allow the application of operations to an entire set of values at once. Such solutions are commonly used in <a href="Computational_science" title="Computational science">scientific</a> and engineering settings.

Modern programming languages that support array programming (also known as <a href="Vector_(data_structure)" class="mw-redirect" title="Vector (data structure)">vector</a> or <a href="Multidimensional_analysis" title="Multidimensional analysis">multidimensional</a> languages) have been engineered specifically to generalize operations on <a href="Scalar_(computing)" class="mw-redirect" title="Scalar (computing)">scalars</a> to apply transparently to <a href="Vector_(geometric)" class="mw-redirect" title="Vector (geometric)">vectors</a>, <a href="Matrix_(mathematics)" title="Matrix (mathematics)">matrices</a>, and higher-dimensional arrays. These include <a href="APL_(programming_language)" title="APL (programming language)">APL</a>, <a href="J_(programming_language)" title="J (programming language)">J</a>, <a href="Fortran" title="Fortran">Fortran</a>, <a href="MATLAB" title="MATLAB">MATLAB</a>, <a href="Analytica_(software)" title="Analytica (software)">Analytica</a>, <a href="GNU_Octave" title="GNU Octave">Octave</a>, <a href="R_(programming_language)" title="R (programming language)">R</a>, <a href="Cilk_Plus" class="mw-redirect" title="Cilk Plus">Cilk Plus</a>, <a href="Julia_(programming_language)" title="Julia (programming language)">Julia</a>, <a href="Perl_Data_Language" title="Perl Data Language">Perl Data Language (PDL)</a>, <a href="Raku_(programming_language)" title="Raku (programming language)">Raku (programming language)</a>. In these languages, an operation that operates on entire arrays can be called a vectorized operation,<a href="#cite_note-1">[1]</a> regardless of whether it is executed on a <a href="Vector_processor" title="Vector processor">vector processor</a>, which implements vector instructions. Array programming primitives concisely express broad ideas about data manipulation. The level of concision can be dramatic in certain cases: it is not uncommon to find array programming language <a href="One-liner_program" title="One-liner program">one-liners</a> that require several pages of object-oriented code.

<div class="mw-heading mw-heading2"><h2 id="Concepts_of_array">Concepts of array</h2></div>

The fundamental idea behind array programming is that operations apply at once to an entire set of values. This makes it a <a href="High-level_programming_language" title="High-level programming language">high-level programming</a> model as it allows the programmer to think and operate on whole aggregates of data, without having to resort to explicit loops of individual scalar operations.

<a href="Kenneth_E._Iverson" title="Kenneth E. Iverson">Kenneth E. Iverson</a> described the rationale behind array programming (actually referring to APL) as follows:<a href="#cite_note-2">[2]</a>

/* start https://en.wikipedia.org/ */

.mw-parser-output .templatequote{overflow:hidden;margin:1em 0;padding:0 32px}.mw-parser-output .templatequotecite{line-height:1.5em;text-align:left;margin-top:0}@media(min-width:500px){.mw-parser-output .templatequotecite{padding-left:1.6em}}

/* end https://en.wikipedia.org/ */

</style><blockquote class="templatequote">most programming languages are decidedly inferior to mathematical notation and are little used as tools of thought in ways that would be considered significant by, say, an applied mathematician.

The thesis is that the advantages of executability and universality found in programming languages can be effectively combined, in a single coherent language, with the advantages offered by mathematical notation. it is important to distinguish the difficulty of describing and of learning a piece of notation from the difficulty of mastering its implications. For example, learning the rules for computing a matrix product is easy, but a mastery of its implications (such as its associativity, its distributivity over addition, and its ability to represent linear functions and geometric operations) is a different and much more difficult matter.

Indeed, the very suggestiveness of a notation may make it seem harder to learn because of the many properties it suggests for explorations.

[...]

Users of computers and programming languages are often concerned primarily with the efficiency of execution of algorithms, and might, therefore, summarily dismiss many of the algorithms presented here. Such dismissal would be short-sighted since a clear statement of an algorithm can usually be used as a basis from which one may easily derive a more efficient algorithm.</blockquote>

The basis behind array programming and thinking is to find and exploit the properties of data where individual elements are similar or adjacent. Unlike object orientation which implicitly breaks down data to its constituent parts (or <a href="Scalar_(computing)" class="mw-redirect" title="Scalar (computing)">scalar</a> quantities), array orientation looks to group data and apply a uniform handling.

Function rank is an important concept to array programming languages in general, by analogy to <a href="Tensor" title="Tensor">tensor</a> rank in mathematics: functions that operate on data may be classified by the number of dimensions they act on. Ordinary multiplication, for example, is a scalar ranked function because it operates on zero-dimensional data (individual numbers). The <a href="Cross_product" title="Cross product">cross product</a> operation is an example of a vector rank function because it operates on vectors, not scalars. <a href="Matrix_multiplication" title="Matrix multiplication">Matrix multiplication</a> is an example of a 2-rank function, because it operates on 2-dimensional objects (matrices). <a href="Reduce_(higher-order_function)" class="mw-redirect" title="Reduce (higher-order function)">Collapse operators</a> reduce the dimensionality of an input data array by one or more dimensions. For example, summing over elements collapses the input array by 1 dimension.

Array programming is very well suited to <a href="Implicit_parallelization" class="mw-redirect" title="Implicit parallelization">implicit parallelization</a>; a topic of much research nowadays. Further, <a href="Intel" title="Intel">Intel</a> and compatible CPUs developed and produced after 1997 contained various instruction set extensions, starting from <a href="MMX_(instruction_set)" title="MMX (instruction set)">MMX</a> and continuing through <a href="SSSE3" title="SSSE3">SSSE3</a> and <a href="3DNow!" title="3DNow!">3DNow!</a>, which include rudimentary <a href="Single_instruction%2C_multiple_data" title="Single instruction, multiple data">SIMD</a> array capabilities. This has continued into the 2020s with instruction sets such as <a href="AVX-512" title="AVX-512">AVX-512</a>, making modern CPUs sophisticated vector processors. Array processing is distinct from <a href="Parallel_computing" title="Parallel computing">parallel processing</a> in that one physical processor performs operations on a group of items simultaneously while parallel processing aims to split a larger problem into smaller ones (<a href="Multiple_instruction%2C_multiple_data" title="Multiple instruction, multiple data">MIMD</a>) to be solved piecemeal by numerous processors. Processors with <a href="Multi-core_processor" title="Multi-core processor">multiple cores</a> and <a href="Graphics_processing_unit" title="Graphics processing unit">GPUs</a> with thousands of <a href="General-purpose_computing_on_graphics_processing_units" title="General-purpose computing on graphics processing units">general computing cores</a> are common as of 2023.

<div class="mw-heading mw-heading2"><h2 id="Languages">Languages</h2></div>

The canonical examples of array programming languages are <a href="Fortran" title="Fortran">Fortran</a>, <a href="APL_(programming_language)" title="APL (programming language)">APL</a>, and <a href="J_(programming_language)" title="J (programming language)">J</a>. Others include: <a href="A%2B_(programming_language)" title="A+ (programming language)">A+</a>, <a href="Analytica_(software)" title="Analytica (software)">Analytica</a>, <a href="Chapel_(programming_language)" title="Chapel (programming language)">Chapel</a>, <a href="IDL_(programming_language)" title="IDL (programming language)">IDL</a>, <a href="Julia_(programming_language)" title="Julia (programming language)">Julia</a>, <a href="K_(programming_language)" title="K (programming language)">K</a>, Klong, <a href="Q_(programming_language_from_Kx_Systems)" title="Q (programming language from Kx Systems)">Q</a>, <a href="MATLAB" title="MATLAB">MATLAB</a>, <a href="GNU_Octave" title="GNU Octave">GNU Octave</a>, <a href="Scilab" title="Scilab">Scilab</a>, <a href="FreeMat" title="FreeMat">FreeMat</a>, <a href="Perl_Data_Language" title="Perl Data Language">Perl Data Language</a> (PDL), <a href="R_(programming_language)" title="R (programming language)">R</a>, <a href="Raku_(programming_language)" title="Raku (programming language)">Raku</a>, <a href="S-Lang" title="S-Lang">S-Lang</a>, <a href="SAC_programming_language" title="SAC programming language">SAC</a>, <a href="Nial" title="Nial">Nial</a>, <a href="ZPL_(programming_language)" class="mw-redirect" title="ZPL (programming language)">ZPL</a>, <a href="Futhark_(programming_language)" title="Futhark (programming language)">Futhark</a>, and <a href="TI-BASIC" title="TI-BASIC">TI-BASIC</a>.

<div class="mw-heading mw-heading3"><h3 id="Scalar_languages">Scalar languages</h3></div>

In scalar languages such as <a href="C_(programming_language)" title="C (programming language)">C</a> and <a href="Pascal_(programming_language)" title="Pascal (programming language)">Pascal</a>, operations apply only to single values, so a+b expresses the addition of two numbers. In such languages, adding one array to another requires indexing and looping, the coding of which is tedious.

<div class="mw-highlight mw-highlight-lang-c mw-content-ltr" dir="ltr"><pre>for (i = 0; i < n; i++)

for (j = 0; j < n; j++)

a[i][j] += b[i][j];

</pre></div>

In array-based languages, for example in Fortran, the nested for-loop above can be written in array-format in one line,

<div class="mw-highlight mw-highlight-lang-fortran mw-content-ltr" dir="ltr"><pre>a = a + b

</pre></div>

or alternatively, to emphasize the array nature of the objects,

<div class="mw-highlight mw-highlight-lang-fortran mw-content-ltr" dir="ltr"><pre>a(:,:) = a(:,:) + b(:,:)

</pre></div>

While scalar languages like C do not have native array programming elements as part of the language proper, this does not mean programs written in these languages never take advantage of the underlying techniques of vectorization (i.e., utilizing a CPU's <a href="Single_instruction%2C_multiple_data" title="Single instruction, multiple data">vector-based instructions</a> if it has them or by using multiple CPU cores). Some C compilers like <a href="GNU_Compiler_Collection" title="GNU Compiler Collection">GCC</a> at some optimization levels detect and vectorize sections of code that its heuristics determine would benefit from it. Another approach is given by the <a href="OpenMP" title="OpenMP">OpenMP</a> API, which allows one to parallelize applicable sections of code by taking advantage of multiple CPU cores.

<div class="mw-heading mw-heading3"><h3 id="Array_languages">Array languages</h3></div>

In array languages, operations are generalized to apply to both scalars and arrays. Thus, a+b expresses the sum of two scalars if a and b are scalars, or the sum of two arrays if they are arrays.

An array language simplifies programming but possibly at a cost known as the abstraction penalty.<a href="#cite_note-3">[3]</a><a href="#cite_note-4">[4]</a><a href="#cite_note-5">[5]</a> Because the additions are performed in isolation from the rest of the coding, they may not produce the optimally most <a href="Algorithmic_efficiency" title="Algorithmic efficiency">efficient</a> code. (For example, additions of other elements of the same array may be subsequently encountered during the same execution, causing unnecessary repeated lookups.) Even the most sophisticated <a href="Optimizing_compiler" title="Optimizing compiler">optimizing compiler</a> would have an extremely hard time amalgamating two or more apparently disparate functions which might appear in different program sections or sub-routines, even though a programmer could do this easily, aggregating sums on the same pass over the array to minimize <a href="Computational_overhead" class="mw-redirect" title="Computational overhead">overhead</a>).

The previous C code would become the following in the <a href="Ada_(programming_language)" title="Ada (programming language)">Ada</a> language,<a href="#cite_note-6">[6]</a> which supports array-programming syntax.

<div class="mw-highlight mw-highlight-lang-ada mw-content-ltr" dir="ltr"><pre>A := A + B;

</pre></div>

APL uses single character Unicode symbols with no syntactic sugar.

<div class="mw-highlight mw-highlight-lang-apl mw-content-ltr" dir="ltr"><pre>A ← A + B

</pre></div>

This operation works on arrays of any rank (including rank 0), and on a scalar and an array. Dyalog APL extends the original language with <a href="Augmented_assignment" title="Augmented assignment">augmented assignments</a>:

<div class="mw-highlight mw-highlight-lang-apl mw-content-ltr" dir="ltr"><pre>A +← B

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Analytica">Analytica</h4></div>

Analytica provides the same economy of expression as Ada.

<pre>A := A + B;

</pre>

<div class="mw-heading mw-heading4"><h4 id="BASIC">BASIC</h4></div>

<a href="Dartmouth_BASIC" title="Dartmouth BASIC">Dartmouth BASIC</a> had MAT statements for matrix and array manipulation in its third edition (1966).

<div class="mw-highlight mw-highlight-lang-basic mw-content-ltr" dir="ltr"><pre>DIM A(4),B(4),C(4)

MAT A = 1

MAT B = 2 * A

MAT C = A + B

MAT PRINT A,B,C

</pre></div>

<a href="Stata" title="Stata">Stata</a>'s matrix programming language Mata supports array programming. Below, we illustrate addition, multiplication, addition of a matrix and a scalar, element by element multiplication, subscripting, and one of Mata's many inverse matrix functions.

<div class="mw-highlight mw-highlight-lang-stata mw-content-ltr" dir="ltr"><pre>. mata:

: A = (1,2,3) \(4,5,6)

: A

1 2 3

+-------------+

1 | 1 2 3 |

2 | 4 5 6 |

+-------------+

: B = (2..4) \(1..3)

: B

1 2 3

+-------------+

1 | 2 3 4 |

2 | 1 2 3 |

+-------------+

: C = J(3,2,1) // A 3 by 2 matrix of ones

: C

1 2

+---------+

1 | 1 1 |

2 | 1 1 |

3 | 1 1 |

+---------+

: D = A + B

: D

1 2 3

+-------------+

1 | 3 5 7 |

2 | 5 7 9 |

+-------------+

: E = A*C

: E

1 2

+-----------+

1 | 6 6 |

2 | 15 15 |

+-----------+

: F = A:*B

: F

1 2 3

+----------------+

1 | 2 6 12 |

2 | 4 10 18 |

+----------------+

: G = E :+ 3

: G

1 2

+-----------+

1 | 9 9 |

2 | 18 18 |

+-----------+

: H = F[(2\1), (1, 2)] // Subscripting to get a submatrix of F and

: // switch row 1 and 2

: H

1 2

+-----------+

1 | 4 10 |

2 | 2 6 |

+-----------+

: I = invsym(F'*F) // Generalized inverse (F*F^(-1)F=F) of a

: // symmetric positive semi-definite matrix

: I

[symmetric]

1 2 3

+-------------------------------------------+

1 | 0 |

2 | 0 3.25 |

3 | 0 -1.75 .9444444444 |

+-------------------------------------------+

: end

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="MATLAB">MATLAB</h4></div>

The implementation in <a href="MATLAB" title="MATLAB">MATLAB</a> allows the same economy allowed by using the Fortran language.

<div class="mw-highlight mw-highlight-lang-matlab mw-content-ltr" dir="ltr"><pre>A = A + B;

</pre></div>

A variant of the MATLAB language is the <a href="GNU_Octave" title="GNU Octave">GNU Octave</a> language, which extends the original language with augmented assignments:

<div class="mw-highlight mw-highlight-lang-octave mw-content-ltr" dir="ltr"><pre>A += B;

</pre></div>

Both MATLAB and GNU Octave natively support <a href="Linear_algebra" title="Linear algebra">linear algebra</a> operations such as matrix multiplication, <a href="Matrix_inversion" class="mw-redirect" title="Matrix inversion">matrix inversion</a>, and the numerical solution of <a href="System_of_linear_equations" title="System of linear equations">system of linear equations</a>, even using the <a href="Moore%E2%80%93Penrose_pseudoinverse" class="mw-redirect" title="Moore–Penrose pseudoinverse">Moore–Penrose pseudoinverse</a>.<a href="#cite_note-7">[7]</a><a href="#cite_note-8">[8]</a>

The <a href="Nial" title="Nial">Nial</a> example of the inner product of two arrays can be implemented using the native matrix multiplication operator. If <code>a</code> is a row vector of size [1 n] and <code>b</code> is a corresponding column vector of size [n 1].

<pre>a * b;

</pre>

By contrast, the <a href="Entrywise_product" class="mw-redirect" title="Entrywise product">entrywise product</a> is implemented as:

<pre>a .* b;

</pre>

The inner product between two matrices having the same number of elements can be implemented with the auxiliary operator <code>(:)</code>, which reshapes a given matrix into a column vector, and the <a href="Transpose" title="Transpose">transpose</a> operator <code>'</code>:

<pre>A(:)' * B(:);

</pre>

<div class="mw-heading mw-heading4"><h4 id="rasql">rasql</h4></div>

The <a href="Rasdaman#Raster_Query_Language" title="Rasdaman">rasdaman query language</a> is a database-oriented array-programming language. For example, two arrays could be added with the following query:

<div class="mw-highlight mw-highlight-lang-sql mw-content-ltr" dir="ltr"><pre>SELECT A + B

FROM A, B

</pre></div>

The R language supports array paradigm by default. The following example illustrates a process of multiplication of two matrices followed by an addition of a scalar (which is, in fact, a one-element vector) and a vector:

<div class="mw-highlight mw-highlight-lang-rout mw-content-ltr" dir="ltr"><pre>> A <- matrix(1:6, nrow=2) # !!this has nrow=2 ... and A has 2 rows

> A

[,1] [,2] [,3]

[1,] 1 3 5

[2,] 2 4 6

> B <- t( matrix(6:1, nrow=2) ) # t() is a transpose operator  !!this has nrow=2 ... and B has 3 rows --- a clear contradiction to the definition of A

> B

[,1] [,2]

[1,] 6 5

[2,] 4 3

[3,] 2 1

> C <- A %*% B

> C

[,1] [,2]

[1,] 28 19

[2,] 40 28

> D <- C + 1

> D

[,1] [,2]

[1,] 29 20

[2,] 41 29

> D + c(1, 1) # c() creates a vector

[,1] [,2]

[1,] 30 21

[2,] 42 30

</pre></div>

Raku supports the array paradigm via its Metaoperators.<a href="#cite_note-9">[9]</a> The following example demonstrates the addition of arrays @a and @b using the Hyper-operator in conjunction with the plus operator.

<div class="mw-highlight mw-highlight-lang-raku mw-content-ltr" dir="ltr"><pre>[0] > my @a = [[1,1],[2,2],[3,3]];

[[1 1] [2 2] [3 3]]

[1] > my @b = [[4,4],[5,5],[6,6]];

[[4 4] [5 5] [6 6]]

[2] > @a »+« @b;

[[5 5] [7 7] [9 9]]

</pre></div>

<div class="mw-heading mw-heading2"><h2 id="Mathematical_reasoning_and_language_notation">Mathematical reasoning and language notation</h2></div>

The matrix left-division operator concisely expresses some semantic properties of matrices. As in the scalar equivalent, if the (<a href="Determinant" title="Determinant">determinant</a> of the) coefficient (matrix) <code>A</code> is not null then it is possible to solve the (vectorial) equation <code>A * x = b</code> by left-multiplying both sides by the <a href="Inverse_matrix" class="mw-redirect" title="Inverse matrix">inverse</a> of <code>A</code>: <code>A−1</code> (in both MATLAB and GNU Octave languages: <code>A^-1</code>). The following mathematical statements hold when <code>A</code> is a <a href="Matrix_rank" class="mw-redirect" title="Matrix rank">full rank</a> <a href="Square_matrix" title="Square matrix">square matrix</a>:

<dd><code>(A^-1 * A)* x ==A^-1 * b </code>       (matrix-multiplication <a href="Associativity" class="mw-redirect" title="Associativity">associativity</a>)</dd>

where <code>==</code> is the equivalence <a href="Relational_operator" title="Relational operator">relational operator</a>.

The previous statements are also valid MATLAB expressions if the third one is executed before the others (numerical comparisons may be false because of round-off errors).

If the system is overdetermined – so that <code>A</code> has more rows than columns – the pseudoinverse <code>A+</code> (in MATLAB and GNU Octave languages: <code>pinv(A)</code>) can replace the inverse <code>A−1</code>, as follows:

<dd><code class="mw-highlight mw-highlight-lang-matlab mw-content-ltr" style="" dir="ltr">(pinv(A) * A)* x ==pinv(A) * b</code>       (matrix-multiplication associativity)</dd>

However, these solutions are neither the most concise ones (e.g. still remains the need to notationally differentiate overdetermined systems) nor the most computationally efficient. The latter point is easy to understand when considering again the scalar equivalent <code>a * x = b</code>, for which the solution <code>x = a^-1 * b</code> would require two operations instead of the more efficient <code>x = b / a</code>.

The problem is that generally matrix multiplications are not <a href="Commutativity" class="mw-redirect" title="Commutativity">commutative</a> as the extension of the scalar solution to the matrix case would require:

<dd><code>(x * a)/ a ==b / a</code>       (commutativity does not hold for matrices!)</dd>

<dd><code>x * (a / a)==b / a</code>       (associativity also holds for matrices)</dd>

The MATLAB language introduces the left-division operator <code>\</code> to maintain the essential part of the analogy with the scalar case, therefore simplifying the mathematical reasoning and preserving the conciseness:

<dd><code>(A \ A)* x ==A \ b</code>       (associativity also holds for matrices, commutativity is no more required)</dd>

This is not only an example of terse array programming from the coding point of view but also from the computational efficiency perspective, which in several array programming languages benefits from quite efficient linear algebra libraries such as <a href="Automatically_Tuned_Linear_Algebra_Software" title="Automatically Tuned Linear Algebra Software">ATLAS</a> or <a href="LAPACK" title="LAPACK">LAPACK</a>.<a href="#cite_note-10">[10]</a>

Returning to the previous quotation of Iverson, the rationale behind it should now be evident: <blockquote class="templatequote">it is important to distinguish the difficulty of describing and of learning a piece of notation from the difficulty of mastering its implications. For example, learning the rules for computing a matrix product is easy, but a mastery of its implications (such as its associativity, its distributivity over addition, and its ability to represent linear functions and geometric operations) is a different and much more difficult matter.

Indeed, the very suggestiveness of a notation may make it seem harder to learn because of the many properties it suggests for explorations.</blockquote>

<div class="mw-heading mw-heading2"><h2 id="Third-party_libraries">Third-party libraries</h2></div>

The use of specialized and efficient libraries to provide more terse abstractions is also common in other programming languages. In <a href="C%2B%2B" title="C++">C++</a> several linear algebra libraries exploit the language's ability to <a href="Operator_overloading" title="Operator overloading">overload operators</a>. In some cases a very terse abstraction in those languages is explicitly influenced by the array programming paradigm, as the <a href="NumPy" title="NumPy">NumPy</a> extension library to <a href="Python_(programming_language)" title="Python (programming language)">Python</a>, <a href="Armadillo_(C%2B%2B_library)" title="Armadillo (C++ library)">Armadillo</a> and <a href="Blitz%2B%2B" title="Blitz++">Blitz++</a> libraries do.<a href="#cite_note-11">[11]</a><a href="#cite_note-12">[12]</a>

<ul><li><a href="Array_slicing" title="Array slicing">Array slicing</a></li>

<li><a href="List_of_programming_languages_by_type#Array_languages" title="List of programming languages by type">List of array programming languages</a></li>

<li><a href="Automatic_vectorization" title="Automatic vectorization">Automatic vectorization</a></li></ul>

<div class="mw-heading mw-heading2"><h2 id="References">References</h2></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .reflist{margin-bottom:0.5em;list-style-type:decimal}@media screen{.mw-parser-output .reflist{font-size:90%}}.mw-parser-output .reflist .references{font-size:100%;margin-bottom:0;list-style-type:inherit}.mw-parser-output .reflist-columns-2{column-width:30em}.mw-parser-output .reflist-columns-3{column-width:25em}.mw-parser-output .reflist-columns{margin-top:0.3em}.mw-parser-output .reflist-columns ol{margin-top:0}.mw-parser-output .reflist-columns li{page-break-inside:avoid;break-inside:avoid-column}.mw-parser-output .reflist-upper-alpha{list-style-type:upper-alpha}.mw-parser-output .reflist-upper-roman{list-style-type:upper-roman}.mw-parser-output .reflist-lower-alpha{list-style-type:lower-alpha}.mw-parser-output .reflist-lower-greek{list-style-type:lower-greek}.mw-parser-output .reflist-lower-roman{list-style-type:lower-roman}

/* end https://en.wikipedia.org/ */

</style><div class="reflist reflist-columns references-column-width" style="column-width: 30em;">

/* start https://en.wikipedia.org/ */

.mw-parser-output cite.citation{font-style:inherit;word-wrap:break-word}.mw-parser-output .citation q{quotes:"\"""\"""'""'"}.mw-parser-output .citation:target{background-color:rgba(0,127,255,0.133)}.mw-parser-output .id-lock-free.id-lock-free a{background:url("./mw/Lock-green.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-limited.id-lock-limited a,.mw-parser-output .id-lock-registration.id-lock-registration a{background:url("./mw/Lock-gray-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-subscription.id-lock-subscription a{background:url("./mw/Lock-red-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .cs1-ws-icon a{background:url("./mw/Wikisource-logo.svg")right 0.1em center/12px no-repeat}body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-free a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-limited a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-registration a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-subscription a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .cs1-ws-icon a{background-size:contain;padding:0 1em 0 0}.mw-parser-output .cs1-code{color:inherit;background:inherit;border:none;padding:inherit}.mw-parser-output .cs1-hidden-error{display:none;color:var(--color-error,#d33)}.mw-parser-output .cs1-visible-error{color:var(--color-error,#d33)}.mw-parser-output .cs1-maint{display:none;color:#085;margin-left:0.3em}.mw-parser-output .cs1-kern-left{padding-left:0.2em}.mw-parser-output .cs1-kern-right{padding-right:0.2em}.mw-parser-output .citation .mw-selflink{font-weight:inherit}@media screen{.mw-parser-output .cs1-format{font-size:95%}html.skin-theme-clientpref-night .mw-parser-output .cs1-maint{color:#18911f}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .cs1-maint{color:#18911f}}

/* end https://en.wikipedia.org/ */

</style><cite id="CITEREFStéfan_van_der_WaltS._Chris_ColbertGaël_Varoquaux2011" class="citation journal cs1">Stéfan van der Walt; S. Chris Colbert & Gaël Varoquaux (2011). "The NumPy array: a structure for efficient numerical computation". Computing in Science and Engineering. 13 (2). IEEE: 22–30. <a href="ArXiv_(identifier)" class="mw-redirect" title="ArXiv (identifier)">arXiv</a>:<a rel="nofollow" class="external text" href="https://arxiv.org/abs/1102.1523">1102.1523</a>. <a href="Bibcode_(identifier)" class="mw-redirect" title="Bibcode (identifier)">Bibcode</a>:<a rel="nofollow" class="external text" href="https://ui.adsabs.harvard.edu/abs/2011CSE....13b..22V">2011CSE....13b..22V</a>. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1109%2Fmcse.2011.37">10.1109/mcse.2011.37</a>. <a href="S2CID_(identifier)" class="mw-redirect" title="S2CID (identifier)">S2CID</a> <a rel="nofollow" class="external text" href="https://api.semanticscholar.org/CorpusID:16907816">16907816</a>.</cite>

</li>

<li id="cite_note-2"><a href="#cite_ref-2">^</a> <cite id="CITEREFIverson1980" class="citation journal cs1"><a href="Kenneth_E._Iverson" title="Kenneth E. Iverson">Iverson, K. E.</a> (1980). <a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F358896.358899">"Notation as a Tool of Thought"</a>. Communications of the ACM. 23 (8): 444–465. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F358896.358899">10.1145/358896.358899</a>.</cite>

</li>

<li id="cite_note-3"><a href="#cite_ref-3">^</a> <cite id="CITEREFSurana_P2006" class="citation thesis cs1">Surana P (2006). <a rel="nofollow" class="external text" href="https://dl.acm.org/doi/book/10.5555/1195058">Meta-Compilation of Language Abstractions</a> (Thesis).</cite>

</li>

<li id="cite_note-4"><a href="#cite_ref-4">^</a> <cite id="CITEREFKuketayev" class="citation web cs1">Kuketayev. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20090111091710/http://www.adtmag.com/joop/article.aspx?id=4597">"The Data Abstraction Penalty (DAP) Benchmark for Small Objects in Java"</a>. Archived from <a rel="nofollow" class="external text" href="http://www.adtmag.com/joop/article.aspx?id=4597">the original</a> on 2009-01-11. Retrieved 2008-03-17.</cite>

</li>

<li id="cite_note-5"><a href="#cite_ref-5">^</a> <cite id="CITEREFChatzigeorgiouStephanides2002" class="citation book cs1">Chatzigeorgiou; Stephanides (2002). "Evaluating Performance and Power Of Object-Oriented Vs. Procedural Programming Languages". In Blieberger; Strohmeier (eds.). <a rel="nofollow" class="external text" href="https://books.google.com/books?id=QMalP1P2kAMC&q=%22abstraction+penalty%22">Proceedings - 7th International Conference on Reliable Software Technologies - Ada-Europe'2002</a>. Springer. p. 367. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-3-540-43784-0</bdi>.</cite>

</li>

<li id="cite_note-6"><a href="#cite_ref-6">^</a> <a rel="nofollow" class="external text" href="http://www.adaic.org/standards/05rm/html/RM-TTL.html">Ada Reference Manual</a>: <a rel="nofollow" class="external text" href="http://www.adaic.org/resources/add_content/standards/05rm/html/RM-G-3-1.html">G.3.1 Real Vectors and Matrices</a>

</li>

<li id="cite_note-7"><a href="#cite_ref-7">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://www.gnu.org/software/octave/doc/interpreter/Arithmetic-Ops.html">"GNU Octave Manual. Arithmetic Operators"</a>. Retrieved 2011-03-19.</cite>

</li>

<li id="cite_note-8"><a href="#cite_ref-8">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20100907074906/http://www.mathworks.com/help/techdoc/ref/arithmeticoperators.html">"MATLAB documentation. Arithmetic Operators"</a>. Archived from <a rel="nofollow" class="external text" href="http://www.mathworks.com/help/techdoc/ref/arithmeticoperators.html">the original</a> on 2010-09-07. Retrieved 2011-03-19.</cite>

</li>

<li id="cite_note-9"><a href="#cite_ref-9">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://docs.raku.org/language/operators#Metaoperators">"Metaoperators section of Raku Operator documentation"</a>.</cite>

</li>

<li id="cite_note-10"><a href="#cite_ref-10">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://www.gnu.org/software/octave/doc/interpreter/Installation.html">"GNU Octave Manual. Appendix G Installing Octave"</a>. Retrieved 2011-03-19.</cite>

</li>

<li id="cite_note-11"><a href="#cite_ref-11">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://arma.sourceforge.net/docs.html#syntax">"Reference for Armadillo 1.1.8. Examples of Matlab/Octave syntax and conceptually corresponding Armadillo syntax"</a>. Retrieved 2011-03-19.</cite>

</li>

<li id="cite_note-12"><a href="#cite_ref-12">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20110323013142/http://www.oonumerics.org/blitz/docs/blitz_3.html#SEC80">"Blitz++ User's Guide. 3. Array Expressions"</a>. Archived from <a rel="nofollow" class="external text" href="http://www.oonumerics.org/blitz/docs/blitz_3.html#SEC80">the original</a> on 2011-03-23. Retrieved 2011-03-19.</cite>

</li>

</ol></div>

<div class="mw-heading mw-heading2"><h2 id="External_links">External links</h2></div>

<ul><li><a rel="nofollow" class="external text" href="http://www.nsl.com/">"No stinking loops" programming</a></li>

<li><a rel="nofollow" class="external text" href="https://web.archive.org/web/20110227013846/http://www.vector.org.uk/archive/v223/smill222.htm">Discovering Array Languages</a></li>

<li><a rel="nofollow" class="external text" href="http://www.zareenacademy.com/">"Types of Arrays" programming</a></li></ul>

/* start https://en.wikipedia.org/ */

.mw-parser-output .hlist dl,.mw-parser-output .hlist ol,.mw-parser-output .hlist ul{margin:0;padding:0}.mw-parser-output .hlist dd,.mw-parser-output .hlist dt,.mw-parser-output .hlist li{margin:0;display:inline}.mw-parser-output .hlist.inline,.mw-parser-output .hlist.inline dl,.mw-parser-output .hlist.inline ol,.mw-parser-output .hlist.inline ul,.mw-parser-output .hlist dl dl,.mw-parser-output .hlist dl ol,.mw-parser-output .hlist dl ul,.mw-parser-output .hlist ol dl,.mw-parser-output .hlist ol ol,.mw-parser-output .hlist ol ul,.mw-parser-output .hlist ul dl,.mw-parser-output .hlist ul ol,.mw-parser-output .hlist ul ul{display:inline}.mw-parser-output .hlist .mw-empty-li{display:none}.mw-parser-output .hlist dt::after{content:": "}.mw-parser-output .hlist dd::after,.mw-parser-output .hlist li::after{content:" · ";font-weight:bold}.mw-parser-output .hlist dd:last-child::after,.mw-parser-output .hlist dt:last-child::after,.mw-parser-output .hlist li:last-child::after{content:none}.mw-parser-output .hlist dd dd:first-child::before,.mw-parser-output .hlist dd dt:first-child::before,.mw-parser-output .hlist dd li:first-child::before,.mw-parser-output .hlist dt dd:first-child::before,.mw-parser-output .hlist dt dt:first-child::before,.mw-parser-output .hlist dt li:first-child::before,.mw-parser-output .hlist li dd:first-child::before,.mw-parser-output .hlist li dt:first-child::before,.mw-parser-output .hlist li li:first-child::before{content:" (";font-weight:normal}.mw-parser-output .hlist dd dd:last-child::after,.mw-parser-output .hlist dd dt:last-child::after,.mw-parser-output .hlist dd li:last-child::after,.mw-parser-output .hlist dt dd:last-child::after,.mw-parser-output .hlist dt dt:last-child::after,.mw-parser-output .hlist dt li:last-child::after,.mw-parser-output .hlist li dd:last-child::after,.mw-parser-output .hlist li dt:last-child::after,.mw-parser-output .hlist li li:last-child::after{content:")";font-weight:normal}.mw-parser-output .hlist ol{counter-reset:listitem}.mw-parser-output .hlist ol>li{counter-increment:listitem}.mw-parser-output .hlist ol>li::before{content:" "counter(listitem)"\a0 "}.mw-parser-output .hlist dd ol>li:first-child::before,.mw-parser-output .hlist dt ol>li:first-child::before,.mw-parser-output .hlist li ol>li:first-child::before{content:" ("counter(listitem)"\a0 "}

/* end https://en.wikipedia.org/ */

</style><style data-mw-deduplicate="TemplateStyles:r1236075235">

/* start https://en.wikipedia.org/ */

.mw-parser-output .navbox{box-sizing:border-box;border:1px solid #a2a9b1;width:100%;clear:both;font-size:88%;text-align:center;padding:1px;margin:1em auto 0}.mw-parser-output .navbox .navbox{margin-top:0}.mw-parser-output .navbox+.navbox,.mw-parser-output .navbox+.navbox-styles+.navbox{margin-top:-1px}.mw-parser-output .navbox-inner,.mw-parser-output .navbox-subgroup{width:100%}.mw-parser-output .navbox-group,.mw-parser-output .navbox-title,.mw-parser-output .navbox-abovebelow{padding:0.25em 1em;line-height:1.5em;text-align:center}.mw-parser-output .navbox-group{white-space:nowrap;text-align:right}.mw-parser-output .navbox,.mw-parser-output .navbox-subgroup{background-color:#fdfdfd}.mw-parser-output .navbox-list{line-height:1.5em;border-color:#fdfdfd}.mw-parser-output .navbox-list-with-group{text-align:left;border-left-width:2px;border-left-style:solid}.mw-parser-output tr+tr>.navbox-abovebelow,.mw-parser-output tr+tr>.navbox-group,.mw-parser-output tr+tr>.navbox-image,.mw-parser-output tr+tr>.navbox-list{border-top:2px solid #fdfdfd}.mw-parser-output .navbox-title{background-color:#ccf}.mw-parser-output .navbox-abovebelow,.mw-parser-output .navbox-group,.mw-parser-output .navbox-subgroup .navbox-title{background-color:#ddf}.mw-parser-output .navbox-subgroup .navbox-group,.mw-parser-output .navbox-subgroup .navbox-abovebelow{background-color:#e6e6ff}.mw-parser-output .navbox-even{background-color:#f7f7f7}.mw-parser-output .navbox-odd{background-color:transparent}.mw-parser-output .navbox .hlist td dl,.mw-parser-output .navbox .hlist td ol,.mw-parser-output .navbox .hlist td ul,.mw-parser-output .navbox td.hlist dl,.mw-parser-output .navbox td.hlist ol,.mw-parser-output .navbox td.hlist ul{padding:0.125em 0}.mw-parser-output .navbox .navbar{display:block;font-size:100%}.mw-parser-output .navbox-title .navbar{float:left;text-align:left;margin-right:0.5em}body.skin--responsive .mw-parser-output .navbox-image img{max-width:none!important}@media print{body.ns-0 .mw-parser-output .navbox{display:none!important}}

/* end https://en.wikipedia.org/ */

</style></div><div role="navigation" class="navbox" aria-labelledby="Programming_paradigms_(Comparison_by_language)368" style="padding:3px"><table class="nowraplinks mw-collapsible autocollapse navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="2"><style data-mw-deduplicate="TemplateStyles:r1239400231">

/* start https://en.wikipedia.org/ */

.mw-parser-output .navbar{display:inline;font-size:88%;font-weight:normal}.mw-parser-output .navbar-collapse{float:left;text-align:left}.mw-parser-output .navbar-boxtext{word-spacing:0}.mw-parser-output .navbar ul{display:inline-block;white-space:nowrap;line-height:inherit}.mw-parser-output .navbar-brackets::before{margin-right:-0.125em;content:"[ "}.mw-parser-output .navbar-brackets::after{margin-left:-0.125em;content:" ]"}.mw-parser-output .navbar li{word-spacing:-0.125em}.mw-parser-output .navbar a>span,.mw-parser-output .navbar a>abbr{text-decoration:inherit}.mw-parser-output .navbar-mini abbr{font-variant:small-caps;border-bottom:none;text-decoration:none;cursor:inherit}.mw-parser-output .navbar-ct-full{font-size:114%;margin:0 7em}.mw-parser-output .navbar-ct-mini{font-size:114%;margin:0 4em}html.skin-theme-clientpref-night .mw-parser-output .navbar li a abbr{color:var(--color-base)!important}@media(prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .navbar li a abbr{color:var(--color-base)!important}}@media print{.mw-parser-output .navbar{display:none!important}}

/* end https://en.wikipedia.org/ */

</style><div id="Programming_paradigms_(Comparison_by_language)368" style="font-size:114%;margin:0 4em"><a href="Programming_paradigm" title="Programming paradigm">Programming paradigms</a> (<a href="Comparison_of_multi-paradigm_programming_languages" title="Comparison of multi-paradigm programming languages">Comparison by language</a>)</div></th></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Imperative_programming" title="Imperative programming">Imperative</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks navbox-subgroup" style="border-spacing:0"><tbody><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Structured_programming" title="Structured programming">Structured</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Jackson_structured_programming" title="Jackson structured programming">Jackson structures</a></li>

<li><a href="Block_(programming)" title="Block (programming)">Block-structured</a></li>

<li><a href="Modular_programming" title="Modular programming">Modular</a></li>

<li><a href="Non-structured_programming" title="Non-structured programming">Non-structured</a></li>

<li><a href="Procedural_programming" title="Procedural programming">Procedural</a></li>

<li><a href="Programming_in_the_large_and_programming_in_the_small" title="Programming in the large and programming in the small">Programming in the large and in the small</a></li>

<li><a href="Design_by_contract" title="Design by contract">Design by contract</a></li>

<li><a href="Invariant-based_programming" title="Invariant-based programming">Invariant-based</a></li>

<li><a href="Nested_function" title="Nested function">Nested function</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Object-oriented_programming" title="Object-oriented programming">Object-oriented</a> (<a href="Comparison_of_programming_languages_(object-oriented_programming)" title="Comparison of programming languages (object-oriented programming)">comparison</a>, <a href="List_of_object-oriented_programming_languages" title="List of object-oriented programming languages">list</a>)</th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Class-based_programming" title="Class-based programming">Class-based</a>, <a href="Prototype-based_programming" title="Prototype-based programming">Prototype-based</a>, <a href="Object-based_language" title="Object-based language">Object-based</a></li>

<li><a href="Agent-oriented_programming" title="Agent-oriented programming">Agent</a></li>

<li><a href="Immutable_object" title="Immutable object">Immutable object</a></li>

<li><a href="Persistent_programming_language" title="Persistent programming language">Persistent</a></li>

<li><a href="Uniform_function_call_syntax" title="Uniform function call syntax">Uniform function call syntax</a></li></ul>

</div></td></tr></tbody></table><div></div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Declarative_programming" title="Declarative programming">Declarative</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks navbox-subgroup" style="border-spacing:0"><tbody><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Functional_programming" title="Functional programming">Functional</a> (<a href="Comparison_of_functional_programming_languages" title="Comparison of functional programming languages">comparison</a>)</th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Recursion_(computer_science)" title="Recursion (computer science)">Recursive</a></li>

<li><a href="Anonymous_function" title="Anonymous function">Anonymous function</a> (<a href="Partial_application" title="Partial application">Partial application</a>)</li>

<li><a href="Higher-order_programming" title="Higher-order programming">Higher-order</a></li>

<li><a href="Purely_functional_programming" title="Purely functional programming">Purely functional</a></li>

<li><a href="Total_functional_programming" title="Total functional programming">Total</a></li>

<li><a href="Strict_programming_language" title="Strict programming language">Strict</a></li>

<li><a href="Generalized_algebraic_data_type" title="Generalized algebraic data type">GADTs</a></li>

<li><a href="Dependent_type" title="Dependent type">Dependent types</a></li>

<li><a href="Functional_logic_programming" title="Functional logic programming">Functional logic</a></li>

<li><a href="Tacit_programming" title="Tacit programming">Point-free style</a></li>

<li><a href="Expression-oriented_programming_language" title="Expression-oriented programming language">Expression-oriented</a></li>

<li><a href="Applicative_programming_language" title="Applicative programming language">Applicative</a>, <a href="Concatenative_programming_language" title="Concatenative programming language">Concatenative</a></li>

<li><a href="Function-level_programming" title="Function-level programming">Function-level</a>, <a href="Value-level_programming" title="Value-level programming">Value-level</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Dataflow_programming" title="Dataflow programming">Dataflow</a></th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Flow-based_programming" title="Flow-based programming">Flow-based</a></li>

<li><a href="Reactive_programming" title="Reactive programming">Reactive</a> (<a href="Functional_reactive_programming" title="Functional reactive programming">Functional reactive</a>)</li>

<li><a href="Signal_programming" class="mw-redirect" title="Signal programming">Signals</a></li>

<li><a href="Stream_processing" title="Stream processing">Streams</a></li>

<li><a href="Synchronous_programming_language" title="Synchronous programming language">Synchronous</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Logic_programming" title="Logic programming">Logic</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Abductive_logic_programming" title="Abductive logic programming">Abductive logic</a></li>

<li><a href="Answer_set_programming" title="Answer set programming">Answer set</a></li>

<li><a href="Constraint_programming" title="Constraint programming">Constraint</a> (<a href="Constraint_logic_programming" title="Constraint logic programming">Constraint logic</a>)</li>

<li><a href="Inductive_logic_programming" title="Inductive logic programming">Inductive logic</a></li>

<li><a href="Nondeterministic_programming" title="Nondeterministic programming">Nondeterministic</a></li>

<li><a href="Ontology_language" title="Ontology language">Ontology</a></li>

<li><a href="Probabilistic_logic_programming" title="Probabilistic logic programming">Probabilistic logic</a></li>

<li><a href="Query_language" title="Query language">Query</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Domain-specific_language" title="Domain-specific language">DSL</a></th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Algebraic_modeling_language" title="Algebraic modeling language">Algebraic modeling</a></li>

<li><a href="Automata-based_programming" title="Automata-based programming">Automata-based</a> (<a href="Action_language" title="Action language">Action</a>)</li>

<li><a href="Command_language" title="Command language">Command</a> (<a href="Spacecraft_command_language" title="Spacecraft command language">Spacecraft</a>)</li>

<li><a href="Differentiable_programming" title="Differentiable programming">Differentiable</a></li>

<li><a href="Grammar-oriented_programming" title="Grammar-oriented programming">Grammar-oriented</a></li>

<li><a href="Interface_description_language" title="Interface description language">Interface description</a></li>

<li><a href="Language-oriented_programming" title="Language-oriented programming">Language-oriented</a></li>

<li><a href="List_comprehension" title="List comprehension">List comprehension</a></li>

<li><a href="Modeling_language" title="Modeling language">Modeling</a></li>

<li><a href="Natural-language_programming" class="mw-redirect" title="Natural-language programming">Natural language</a></li>

<li><a href="Non-English-based_programming_languages" title="Non-English-based programming languages">Non-English-based</a></li>

<li><a href="Page_description_language" title="Page description language">Page description</a></li>

<li><a href="Pipeline_(software)" title="Pipeline (software)">Pipes</a> and <a href="Filter_(software)" title="Filter (software)">filters</a></li>

<li><a href="Probabilistic_programming" title="Probabilistic programming">Probabilistic</a></li>

<li><a href="Quantum_programming" title="Quantum programming">Quantum</a></li>

<li><a href="Scientific_programming_language" title="Scientific programming language">Scientific</a></li>

<li><a href="Scripting_language" title="Scripting language">Scripting</a></li>

<li><a href="Set_theoretic_programming" title="Set theoretic programming">Set-theoretic</a></li>

<li><a href="Simulation_language" title="Simulation language">Simulation</a></li>

<li><a href="Stack-oriented_programming" title="Stack-oriented programming">Stack-based</a></li>

<li><a href="System_programming_language" title="System programming language">System</a></li>

<li><a href="Tactile_programming_language" title="Tactile programming language">Tactile</a></li>

<li><a href="Template_processor" title="Template processor">Templating</a></li>

<li><a href="Transformation_language" title="Transformation language">Transformation</a> (<a href="Graph_rewriting" title="Graph rewriting">Graph rewriting</a>, <a href="Production_system_(computer_science)" title="Production system (computer science)">Production</a>, <a href="Pattern_matching" title="Pattern matching">Pattern</a>)</li>

<li><a href="Visual_programming_language" title="Visual programming language">Visual</a></li></ul>

</div></td></tr></tbody></table><div></div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Concurrent_computing" title="Concurrent computing">Concurrent</a>, <a href="Distributed_computing" title="Distributed computing">distributed</a>, <a href="Parallel_computing" title="Parallel computing">parallel</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Actor_model" title="Actor model">Actor-based</a></li>

<li><a href="Automatic_mutual_exclusion" title="Automatic mutual exclusion">Automatic mutual exclusion</a></li>

<li><a href="Choreographic_programming" title="Choreographic programming">Choreographic programming</a></li>

<li><a href="Concurrent_logic_programming" title="Concurrent logic programming">Concurrent logic</a> (<a href="Concurrent_constraint_logic_programming" title="Concurrent constraint logic programming">Concurrent constraint logic</a>)</li>

<li><a href="Concurrent_object-oriented_programming" title="Concurrent object-oriented programming">Concurrent OO</a></li>

<li><a href="Macroprogramming" title="Macroprogramming">Macroprogramming</a></li>

<li><a href="Multitier_programming" title="Multitier programming">Multitier programming</a></li>

<li><a href="Organic_computing" title="Organic computing">Organic computing</a></li>

<li><a href="Parallel_programming_model" title="Parallel programming model">Parallel programming models</a></li>

<li><a href="Partitioned_global_address_space" title="Partitioned global address space">Partitioned global address space</a></li>

<li><a href="Process-oriented_programming" title="Process-oriented programming">Process-oriented</a></li>

<li><a href="Relativistic_programming" title="Relativistic programming">Relativistic programming</a></li>

<li><a href="Service-oriented_programming" title="Service-oriented programming">Service-oriented</a></li>

<li><a href="Structured_concurrency" title="Structured concurrency">Structured concurrency</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Metaprogramming" title="Metaprogramming">Metaprogramming</a></th><td class="navbox-list-with-group navbox-list navbox-even hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Attribute-oriented_programming" title="Attribute-oriented programming">Attribute-oriented</a></li>

<li><a href="Automatic_programming" title="Automatic programming">Automatic</a> (<a href="Inductive_programming" title="Inductive programming">Inductive</a>)</li>

<li><a href="Dynamic_programming_language" title="Dynamic programming language">Dynamic</a></li>

<li><a href="Extensible_programming" title="Extensible programming">Extensible</a></li>

<li><a href="Generic_programming" title="Generic programming">Generic</a></li>

<li><a href="Homoiconicity" title="Homoiconicity">Homoiconicity</a></li>

<li><a href="Interactive_programming" title="Interactive programming">Interactive</a></li>

<li><a href="Macro_(computer_science)" title="Macro (computer science)">Macro</a> (<a href="Hygienic_macro" title="Hygienic macro">Hygienic</a>)</li>

<li><a href="Metalinguistic_abstraction" title="Metalinguistic abstraction">Metalinguistic abstraction</a></li>

<li><a href="Multi-stage_programming" title="Multi-stage programming">Multi-stage</a></li>

<li><a href="Program_synthesis" title="Program synthesis">Program synthesis</a> (<a href="Bayesian_program_synthesis" title="Bayesian program synthesis">Bayesian</a>, <a href="Inferential_programming" title="Inferential programming">Inferential</a>, <a href="Programming_by_demonstration" title="Programming by demonstration">by demonstration</a>, <a href="Programming_by_example" title="Programming by example">by example</a>)</li>

<li><a href="Reflective_programming" title="Reflective programming">Reflective</a></li>

<li><a href="Self-modifying_code" title="Self-modifying code">Self-modifying code</a></li>

<li><a href="Symbolic_programming" title="Symbolic programming">Symbolic</a></li>

<li><a href="Template_metaprogramming" title="Template metaprogramming">Template</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Separation_of_concerns" title="Separation of concerns">Separation of concerns</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Aspect-oriented_programming" title="Aspect-oriented programming">Aspects</a></li>

<li><a href="Component-based_software_engineering" title="Component-based software engineering">Components</a></li>

<li><a href="Data-driven_programming" title="Data-driven programming">Data-driven</a></li>

<li><a href="Data-oriented_design" title="Data-oriented design">Data-oriented</a></li>

<li><a href="Event-driven_programming" title="Event-driven programming">Event-driven</a></li>

<li><a href="Feature-oriented_programming" title="Feature-oriented programming">Features</a></li>

<li><a href="Literate_programming" title="Literate programming">Literate</a></li>

<li><a href="Role-oriented_programming" title="Role-oriented programming">Roles</a></li>

<li><a href="Subject-oriented_programming" title="Subject-oriented programming">Subjects</a></li></ul>

</div></td></tr></tbody></table></div>

<div class="navbox-styles"></div><div role="navigation" class="navbox" aria-labelledby="Types_of_programming_languages107" style="padding:3px"><table class="nowraplinks mw-collapsible autocollapse navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="2"><div id="Types_of_programming_languages107" style="font-size:114%;margin:0 4em"><a href="Programming_paradigm" title="Programming paradigm">Types of programming languages</a></div></th></tr><tr><th scope="row" class="navbox-group" style="width:1%">Level</th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Machine_code" title="Machine code">Machine</a></li>

<li><a href="Assembly_language" title="Assembly language">Assembly</a></li>

<li><a href="Compiled_language" title="Compiled language">Compiled</a></li>

<li><a href="Interpreted_language" class="mw-redirect" title="Interpreted language">Interpreted</a></li></ul>

<ul><li><a href="Low-level_programming_language" title="Low-level programming language">Low-level</a></li>

<li><a href="High-level_programming_language" title="High-level programming language">High-level</a></li>

<li><a href="Very_high-level_programming_language" title="Very high-level programming language">Very high-level</a></li>

<li><a href="Esoteric_programming_language" title="Esoteric programming language">Esoteric</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Programming_language_generations" title="Programming language generations">Generation</a></th><td class="navbox-list-with-group navbox-list navbox-even hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="First-generation_programming_language" title="First-generation programming language">First</a></li>

<li><a href="Second-generation_programming_language" title="Second-generation programming language">Second</a></li>

<li><a href="Third-generation_programming_language" title="Third-generation programming language">Third</a></li>

<li><a href="Fourth-generation_programming_language" title="Fourth-generation programming language">Fourth</a></li>

<li><a href="Fifth-generation_programming_language" title="Fifth-generation programming language">Fifth</a></li></ul>

</div></td></tr></tbody></table></div></div><div><div class="zim-footer">

This article is issued from <a class="external text" title="Last edited on 2025-01-22" href="https://en.wikipedia.org/wiki/?title=Array_programming&oldid=1271129840">Wikipedia</a>. The text is available under <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.en">Creative Commons Attribution-Share Alike 4.0</a> unless otherwise noted. Additional terms may apply for the media files.

</div>

</div></div>

</div>

</main>

</div>

</body></html>